package qc.module.ehs.api.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import qc.common.core.exception.QCPromptException;
import qc.module.ehs.dto.check.*;
import qc.module.ehs.service.EhsCheckGroupService;
import qc.module.ehs.service.EhsCheckItemService;
import qc.module.ehs.service.EhsCheckTableService;

import java.util.List;

/**
 * CheckTableController
 *
 * @author QuCheng Tech
 * @create 2024/10/23
 */
@RestController
@RequestMapping("/check")
public class CheckTableController {
    
    @Autowired
    private EhsCheckTableService checkTableService;
    
    @Autowired
    private EhsCheckGroupService checkGroupService;
    
    @Autowired
    private EhsCheckItemService checkItemService;

    //是否为逻辑删除，为true表示逻辑删除--修改记录标记，为false表示物理删除--从数据库表中删除记录
    private static final boolean isLogicDelete = false;

    //------------------检查表相关接口--------------------------------
    /**
     * 查询检查表
     * 
     * @param condition 查询条件DTO
     * @return List<CheckTableDto>
     * @author QuCheng Tech
     * @since 2024/10/23
     * @description 用于检查表维护模块和在工作任务模块中获取指定任务类型中的待选择检查表；
     */
    @RequestMapping(value = "/querytable",method = {RequestMethod.GET,RequestMethod.POST})
    public List<CheckTableDto> queryTable(@RequestBody CheckTableQueryConditionDto condition) throws QCPromptException {
        return checkTableService.queryTable(condition);
    }

    /**
     * 获取指定检查表完整信息
     * 
     * @param id 检查表ID
     * @return CheckTableFullDto
     * @author QuCheng Tech
     * @since 2024/10/23
     */
    @GetMapping("/gettablefull")
    public CheckTableFullDto getTableFullByParam(@RequestParam String id) throws QCPromptException {
        return checkTableService.getTableFull(id);
    }

    /**
     * 获取指定检查表完整信息
     *
     * @param id 检查表ID
     * @return CheckTableFullDto
     * @author QuCheng Tech
     * @since 2024/10/23
     */
    @GetMapping("/gettablefull/{id}")
    public CheckTableFullDto getTableFullByPath(@PathVariable String id) throws QCPromptException {
        return checkTableService.getTableFull(id);
    }

    /**
     * 获取指定检查表
     * 
     * @param id 检查表ID
     * @return CheckTableDto
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @GetMapping("/gettable")
    public CheckTableDto getTableByParam(@RequestParam String id){
        return checkTableService.get(id);
    }

    /**
     * 获取指定检查表
     *
     * @param id 检查表ID
     * @return CheckTableDto
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @GetMapping("/gettable/{id}")
    public CheckTableDto getTableByPath(@PathVariable String id){
        return checkTableService.get(id);
    }

    /**
     * 新增检查表
     * 
     * @param dto 新增对象DTO
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @RequestMapping(value = "/addtable",method = {RequestMethod.POST})
    public String addTable(@RequestBody CheckTableDto dto){
        return checkTableService.add(dto);
    }

    /**
     * 修改检查表
     * 
     * @param dto 修改对象DTO
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @RequestMapping(value = "/updatetable",method = {RequestMethod.POST,RequestMethod.PUT})
    public String updateTable(@RequestBody CheckTableDto dto){
        return checkTableService.update(dto);
    }

    /**
     * 删除检查表
     *
     * @param id 检查表ID
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     * @description 同时删除检查项分组和检查项
     */
    @DeleteMapping("/deletetable")
    public String deleteByParam(@RequestParam String id){
        return checkTableService.delete(id,isLogicDelete);
    }

    /**
     * 删除检查表
     *
     * @param id 检查表ID
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     * @description 同时删除检查项分组和检查项
     */
    @DeleteMapping("/deletetable/{id}")
    public String deleteByPath(@PathVariable String id){
        return checkTableService.delete(id,isLogicDelete);
    }

    /**
     * 获取指定表的分组
     * 
     * @param id 检查表ID
     * @return List<CheckGroupDto>
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @GetMapping("/tablegroups")
    public List<CheckGroupDto> getTableGroupsByParam(@RequestParam String id){
        return checkGroupService.getTableGroups(id);
    }

    /**
     * 获取指定表的分组
     *
     * @param id 检查表ID
     * @return List<CheckGroupDto>
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @GetMapping("/tablegroups/{id}")
    public List<CheckGroupDto> getTableGroupsByPath(@PathVariable String id){
        return checkGroupService.getTableGroups(id);
    }

    //------------------检查项分组相关接口--------------------------------

    /**
     * 获取指定检查表分组
     *
     * @param id 检查表分组ID
     * @return CheckGroupDto
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @GetMapping("/getgroup")
    public CheckGroupDto getGroupByParam(@RequestParam String id){
        return checkGroupService.get(id);
    }

    /**
     * 获取指定检查表分组
     * 
     * @param id 检查表分组ID
     * @return CheckGroupDto
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @GetMapping("/getgroup/{id}")
    public CheckGroupDto getGroupByPath(@PathVariable String id){
        return checkGroupService.get(id);
    }

    /**
     * 新增检查分组
     * 
     * @param dto 新增对象DTO
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @RequestMapping(value = "/addgroup",method = {RequestMethod.POST})
    public String addGroup(@RequestBody CheckGroupDto dto){
        return checkGroupService.add(dto);
    }

    /**
     * 修改检查分组
     *
     * @param dto 新增对象DTO
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @RequestMapping(value = "/updategroup",method = {RequestMethod.POST,RequestMethod.PUT})
    public String updateGroup(@RequestBody CheckGroupDto dto){
        return checkGroupService.update(dto);
    }

    /**
     * 删除检查分组
     *
     * @param id 检查分组ID
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     * @description 同时删除检查项
     */
    @DeleteMapping("/deletegroup")
    public String deleteGroupByParam(@RequestParam String id){
        return checkGroupService.delete(id,isLogicDelete);
    }

    /**
     * 删除检查分组
     * 
     * @param id 检查分组ID
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     * @description 同时删除检查项
     */
    @DeleteMapping("/deletegroup/{id}")
    public String deleteGroupByPath(@PathVariable String id){
        return checkGroupService.delete(id,isLogicDelete);
    }

    //------------------检查项相关接口--------------------------------

    /**
     * 获取指定分组的检查项
     *  
     * @param id 检查表分组ID
     * @return List<CheckItemDto>
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @GetMapping("/groupitems")
    public List<CheckItemDto> getGroupItemsByParam(@RequestParam String id){
        return checkItemService.getGroupItems(id);
    }

    /**
     * 获取指定分组的检查项
     *
     * @param id 检查表分组ID
     * @return List<CheckItemDto>
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @GetMapping("/groupitems/{id}")
    public List<CheckItemDto> getGroupItemsByPath(@PathVariable String id){
        return checkItemService.getGroupItems(id);
    }

    /**
     * 获取指定检查项
     * 
     * @param id 检查项ID
     * @return CheckItemDto
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @GetMapping("/getitem")
    public CheckItemDto getItemByParam(@RequestParam String id){
        return checkItemService.get(id);
    }

    /**
     * 获取指定检查项
     *
     * @param id 检查项ID
     * @return CheckItemDto
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @GetMapping("/getitem/{id}")
    public CheckItemDto getItemByPath(@PathVariable String id){
        return checkItemService.get(id);
    }

    /**
     * 新增检查项
     * 
     * @param dto 新增对象DTO
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @RequestMapping(value = "/additem",method = {RequestMethod.POST})
    public String addItem(@RequestBody CheckItemDto dto){
        return checkItemService.add(dto);
    }

    /**
     * 修改检查表
     * 
     * @param dto 修改对象DTO
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @RequestMapping(value = "/updateitem",method = {RequestMethod.POST,RequestMethod.PUT})
    public String updateItem(@RequestBody CheckItemDto dto){
        return checkItemService.update(dto);
    }

    /**
     * 删除检查项
     * 
     * @param id 检查项ID
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @DeleteMapping("/deleteitem")
    public String deleteItemByParam(@RequestParam String id){
        return checkItemService.delete(id,isLogicDelete);
    }

    /**
     * 删除检查项
     *
     * @param id 检查项ID
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/10/24
     */
    @DeleteMapping("/deleteitem/{id}")
    public String deleteItemByPath(@PathVariable String id) {
        return checkItemService.delete(id, isLogicDelete);
    }

    /***
     * 批量新增检查项
     *
     * @param dto 批量新增检查项DTO
     * @return java.lang.String
     * @author QuCheng Tech
     * @since 2025/2/10
     */
    @RequestMapping(value = "/batchadditem", method = {RequestMethod.POST})
    public String batchAddItems(@RequestBody CheckItemBatchAddDto dto) {
        return checkItemService.batchAdd(dto);
    }
}
